package 集合.双列集合;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

public class main {
    /*
    1.双列集合一次需要存储一对数据，分别为键和值
    2.键不能重复，值可以重复
    3.键和值是一一对应的，每一个键都有自己的值
    4.键和值这个整体我们称为键值对，或者键值对对象，在java中叫做entry对象

    Map{HahsMap-->LinkedHashMap         TreeMap}
     */
    public static void main(String[] args) {
//        Map是双列集合的顶层接口，它的功能是全部双列集合都可以继承使用的
//        HashMap是map里面的一个实现类，可以使用map里的方法.特点：无序，不重复，无索引
//        LinkedHashMap特点：有序，不重复，无索引
//        TreeMap：不重复，无索引，可排序（在类中使用接口 Comparable进行排序），或者使用comparator
//        1.javabean类实现Comparable接口，指定比较规则(默认方式)
//        在使用第二种方式的前提是：方式一无法满足要求（例如Integer类型，或者按照从小到大的方式排列。。）
//        两种方式同时存在，以第二种方式为准
//        2.创建集合时，自定义Comparator比较器对象，指定比较规则
        /*
        V put(k key ,V value)                   添加元素
        V remove(object key)                    根据键删除键值对应元素
        void clear()                            移除所有键值对元素
        boolean containsKey(object key)         判断集合是否包含指定的键
        boolean containsValue(object Value)     判断集合是否包含指定的值
        boolean isEmpty()                       判断集合是否为空
        int size                                集合的长度，也就是集合中键值对的个数
        default void forEach(BiConsumer<? super k,? super v>action)   结合lambda遍历map集合
         */

//        Map是一个接口，不能直接创建对象，创建的是是在哪类对象
//        第一个String是键的类型，第二个String是值的类型
        Map<String,String> map=new HashMap();
//        添加元素
        map.put("11","12");
        map.put("21","22");
        map.put("31","32");
        map.put("41","42");
        map.put("51","52");
        System.out.println(map);
//      这种方式不为添加，而是覆盖，会返回被覆盖的值
        String value=map.put("21","33");
        System.out.println(value);//22
//        如果为之前没有的元素，则会返回null
        String value1=map.put("61","62");
        System.out.println(value1);//null
        System.out.println(map.containsKey("11"));
        System.out.println(map.containsValue("52"));
        System.out.println(map.isEmpty());
        System.out.println(map.size());

//        遍历方式
//        1.键找值：步骤一:获得所有的键，放到单列集合当中
        Set<String> keys = map.keySet();
//        步骤二：遍历单列集合，获得所有的键
        for (String key : keys) {
//            System.out.println(key);遍历获得键
//            利用map集合的键获取每个对应的值
            String s = map.get(key);//返回键对应的值
            System.out.println(key+"="+s);
        }
        /*
        获得键
      Set<String> key1 = map.keySet();
        Iterator<String> it= key1.iterator();
        while(it.hasNext()){
            String next = it.next();
            System.out.println(next);
        }

         */
/*
            获得键
            Set<String> keys = map.keySet();
            keys.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/
        System.out.println("---------------------------------");
//        通过一个方法获取所有的键值对对象，返回一个Set集合
        Set<Map.Entry<String, String>> entries = map.entrySet();
//        遍历entries这个集合，得到里面的每一个键值对对象
        for (Map.Entry<String, String> entry : entries) {
            String key = entry.getKey();//返回键
            String value2 = entry.getValue();//返回值
            System.out.println(key+"="+value2);
        }
        System.out.println("---------------------lambda----------------------------");
        map.forEach(new BiConsumer<String, String>() {
            @Override
            public void accept(String s, String s2) {
                System.out.println(s+"="+s2);
            }
        });
    }
}
